C syntax

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages) This article includes a list of general references, but it lacks sufficient corresponding inline citations. Please help to improve this article by introducing more precise citations. (March 2015) (Learn how and when to remove this message) This article needs to be updated. Please help update this article to reflect recent events or newly available information. (July 2021) (Learn how and when to remove this message)

C syntax is the form that text must have in order to be C programming language code. The language syntax rules are designed to allow for code that is terse, has a close relationship with the resulting object code, and yet provides relatively high-level data abstraction. C was the first widely successful high-level language for portable operating-system development. C syntax makes use of the maximal munch principle. As a free-form language, C code can be formatted different ways without affecting its syntactic nature. C syntax influenced the syntax of succeeding languages, including C++, Java, and C#.

C code consists of preprocessor directives, and core-language types, variables and functions; organized as one or more source files. Building the code typically involves preprocessing and then compiling each source file into an object file. Then, the object files are linked to create an executable image.

Variables and functions can be declared separately from their definition. A declaration identifies the name of a user-defined element and some if not all of the information about how the element can be used at run-time. A definition is a complete description of an element that includes the declaration aspect as well as additional information that completes the element. For example, a function declaration indicates the name and optionally the type and number of arguments that it accepts. A function definition includes the same information (argument information is not optional), plus code that implements the function logic.

For a hosted environment, a program starts at an entry point function named main. The function is passed two arguments although an implementation of the function can ignore them. The function must be declared per one of the following prototypes (parameter names shown are typical but can be anything):

int main() {...}
int main(void) {...}
int main(int argc, char *argv[]) {...}
int main(int argc, char **argv) {...}

The first two definitions are equivalent; meaning that the function does not use the two arguments. The second two are also equivalent; allowing the function to access the two arguments.

The return value, typed as int, serves as a status indicator to the host environment. Defined in <stdlib.h>, the standard library provides macros for standard status values: EXIT_SUCCESS and EXIT_FAILURE. Regardless, a program can indicate status using any values. For example, the kill command returns the numerical value of the signal plus 128.

A minimal program consists of a parameterless, empty main function, like:

int main(){}

Unlike other functions, the language^[a] requires that a program act as if it returns 0 even if it does not end with a return statement.^[1]

In a free-standing (non-hosted) environment, such as a system without an operating system, the standard allows for different startup handling. It need not require a main function.

Arguments included in the command line to start a program are passed to a program as two values – the number of arguments (customarily named argc) and an array of null-terminated strings (customarily named argv) with the program name as the first item. The following command results in argc: 4, argv[0]: "myFilt", argv[1]: "abc", argv[2]: "def".

myFilt abc def

The following code prints the value of the command-line parameters.

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("argc\t= %d\n", argc);
    for (int i = 0; i < argc; i++)
        printf("argv[%i]\t= %s\n", i, argv[i]);
}

The following words are reserved – not allowed as identifiers:

The following keywords are often substituted for a macro or an appropriate keyword from the above list. Some of the following keywords are deprecated since C23.

Implementations may reserve other keywords, although implementations typically provide non-standard keywords that begin with one or two underscores. The following keywords are classified as extensions and conditionally-supported:

The following are directives to the preprocessor.

The _Pragma operator provides an alternative syntax for the functionality provided by #pragma.

A comment – informative text to a programmer that is ignored by a language translator – can be included in code either as the line or block comment syntax. A line comment starts with // and ends at the end of the same line. A block comment starts with /* and ends with */ – spanning any number of lines (or just one).

In some situations, comment markers are ignored. The text of a string literal is exempt from being considered a comment start. And, comments cannot be nested. For example, /* in a line comment is not as treated as the start of a block comment. And, // in a block comment is not treated as the start of a line comment.

The line comment syntax, sometimes called C++ style originated in BCPL and became valid syntax in C99. It is not available in the original K&R version nor in ANSI C.

The following code demonstrates comments. Line 1 contains a line comment and lines 3-4 contain a block comment. Line 4 demonstrates that a block comment can be embedded in a line with code both before and after it.

int i; // line comment
/* block
   comment */
int ii = /* always zero */ 0;

The following demonstrates a potential problem with the comment syntax. What is intended to be the divide operator / and then the dereference operator *, is evaluated as the start of a block comment.

x = *p/*q;

The following text is not valid C syntax since comments do not nest. It seems that lines 3-5 are a comment nested inside the comment block spanning lines 1-7. But, actually line 5 ends the comment started on line 1. This leaves line 6 to be interpreted as code which is clearly not valid C syntax.

/*
First of comment block
/*
First line of what is intended to be an inner block
*/
Compiler treats this line as code but it's not valid!
*/

The syntax supports user-defined identifiers. An identifier must start with a letter (A-Z, a-z) or an underscore (_), subsequent characters can be letters, numbers (0-9), or underscores and it must not be a reserved word. Identifiers are case sensitive; making foo, FOO, and Foo distinct.

There can be multiple ways to evaluation an expression consistent with the mathematical notation. For example, (1+1)+(3+3) may be evaluated in the order (1+1)+(3+3), (2)+(3+3), (2)+(6), (8), or in the order (1+1)+(3+3), (1+1)+(6), (2)+(6), (8).

To reduce run-time issues with evaluation order yet afford some optimizations, the standard states that expressions may be evaluated in any order between sequence points which are defined as any of the following:

• Statement end
• A sequencing operator: a comma; commas that delimit function arguments are not sequence points
• A short-circuit operators: logical and (&&, which can be read and then) and logical or (||, which can be read or else)
• A ternary operator (?:): This operator evaluates its first sub-expression first, and then its second or third (never both of them) based on the value of the first
• Entry to and exit from a function call (but not between evaluations of the arguments)

Expressions before a sequence point are always evaluated before those after a sequence point. In the case of short-circuit evaluation, the second expression may not be evaluated depending on the result of the first expression. For example, in the expression (a() || b()), if the first argument evaluates to nonzero (true), the result of the entire expression cannot be anything else than true, so b() is not evaluated. Similarly, in the expression (a() && b()), if the first argument evaluates to zero (false), the result of the entire expression cannot be anything else than false, so b() is not evaluated.

The arguments to a function call may be evaluated in any order, as long as they are all evaluated by the time the function is entered. The following expression, for example, has undefined behavior:

printf("%s %s\n", argv[i = 0], argv[++i]);

The language supports primitive numeric types for integer and real values which typically map directly to the instruction set architecture of a central processing unit (CPU). Integer data types store values in a subset of integers, and real data types store values in a subset of real numbers in floating-point. A complex data type stores two real values.

Integer types have signed and unsigned variants. If neither is specified, signed is assumed, in most circumstances. However, for historic reasons, char is a type distinct from both signed char and unsigned char. It may be signed or unsigned, depending on the compiler and the character set (the standard requires that members of the basic character set have positive values). Also, bit field types specified as int may be signed or unsigned, depending on the compiler.

The integer types come in different fixed sizes, capable of representing various ranges of numbers. The type char occupies exactly one byte (the smallest addressable storage unit), which is typically 8 bits wide. (Although char can represent any "basic" character, a wider type may be required for international character sets.) Most integer types have both signed and unsigned varieties, designated by the signed and unsigned keywords. Signed integer types always use the two's complement representation, since C23^[2] (and in practice before; in versions before C23 the representation might alternatively have been ones' complement, or sign-and-magnitude, but in practice that has not been the case for decades on modern hardware). In many cases, there are multiple equivalent ways to designate the type; for example, signed short int and short are synonymous.

The representation of some types may include unused "padding" bits, which occupy storage but are not included in the width. The following table lists the integer types using the shortest possible name and indicating the minimum width in bits.

The char type is distinct from both signed char and unsigned char, but is guaranteed to have the same representation as one of them. The _Bool and long long types are standardized since 1999, and may not be supported by older compilers. Type _Bool is usually accessed via the typedef name bool defined by the standard header <stdbool.h>, however since C23 the _Bool type has been renamed bool, and <stdbool.h> has been deprecated.

In general, the widths and representation scheme implemented for any given platform are chosen based on the machine architecture, with some consideration given to the ease of importing source code developed for other platforms. The width of the int type varies especially between translators; often corresponds to the most "natural" word size for a platform. The standard header limits.h defines macros for the minimum and maximum representable values of the standard integer types as implemented on any specific platform.

In addition to the standard integer types, there may be other "extended" integer types, which can be used for typedefs in standard headers. For more precise specification of width, programmers can and should use typedefs from the standard header stdint.h.

Integer constants may be specified in source code in several ways. Numeric values can be specified as decimal (example: 1022), octal with zero (0) as a prefix (01776), or hexadecimal with 0x (zero x) as a prefix (0x3FE). A character in single quotes (example: 'R'), called a "character constant," represents the value of that character in the execution character set, with type int. Except for character constants, the type of an integer constant is determined by the width required to represent the specified value, but is always at least as wide as int. This can be overridden by appending an explicit length and/or signedness modifier; for example, 12lu has type unsigned long. There are no negative integer constants, but the same effect can often be obtained by using a unary negation operator "-".

The enumerated type, specified with the enum keyword, and often just called an "enum" (usually pronounced /ˈiːnʌm/ EE-num or /ˈiːnuːm/ EE-noom), is a type designed to represent values across a series of named constants. Each of the enumerated constants has type int. Each enum type itself is compatible with char or a signed or unsigned integer type, but each implementation defines its own rules for choosing a type.

Some compilers warn if an object with enumerated type is assigned a value that is not one of its constants. However, such an object can be assigned any values in the range of their compatible type, and enum constants can be used anywhere an integer is expected. For this reason, enum values are often used in place of preprocessor #define directives to create named constants. Such constants are generally safer to use than macros, since they reside within a specific identifier namespace.

An enumerated type is declared with the enum specifier and an optional name (or tag) for the enum, followed by a list of one or more constants contained within curly braces and separated by commas, and an optional list of variable names. Subsequent references to a specific enumerated type use the enum keyword and the name of the enum. By default, the first constant in an enumeration is assigned the value zero, and each subsequent value is incremented by one over the previous constant. Specific values may also be assigned to constants in the declaration, and any subsequent constants without specific values will be given incremented values from that point onward. For example, consider the following declaration:

enum colors { RED, GREEN, BLUE = 5, YELLOW } paint_color;

This declares the enum colors type; the int constants RED (whose value is 0), GREEN (whose value is one greater than RED, 1), BLUE (whose value is the given value, 5), and YELLOW (whose value is one greater than BLUE, 6); and the enum colors variable paint_color. The constants may be used outside of the context of the enum (where any integer value is allowed), and values other than the constants may be assigned to paint_color, or any other variable of type enum colors.

A floating-point form is used to represent numbers with a fractional component. They do not, however, represent most rational numbers exactly; they are instead a close approximation. There are three standard types of real values, denoted by their specifiers (and since C23 three more decimal types): single precision (float), double precision (double), and double extended precision (long double). Each of these may represent values in a different form, often one of the IEEE floating-point formats.

Floating-point constants may be written in decimal notation, e.g. 1.23. Decimal scientific notation may be used by adding e or E followed by a decimal exponent, also known as E notation, e.g. 1.23e2 (which has the value 1.23 × 10² = 123.0). Either a decimal point or an exponent is required (otherwise, the number is parsed as an integer constant). Hexadecimal floating-point constants follow similar rules, except that they must be prefixed by 0x and use p or P to specify a binary exponent, e.g. 0xAp-2 (which has the value 2.5, since A_h × 2⁻² = 10 × 2⁻² = 10 ÷ 4). Both decimal and hexadecimal floating-point constants may be suffixed by f or F to indicate a constant of type float, by l (letter l) or L to indicate type long double, or left unsuffixed for a double constant.

The standard header file float.h defines the minimum and maximum values of the implementation's floating-point types float, double, and long double. It also defines other limits that are relevant to the processing of floating-point numbers.

C23 introduces three additional decimal (as opposed to binary) real floating-point types: _Decimal32, _Decimal64, and _Decimal128.

NOTE C does not specify a radix for float, double, and long double. An implementation can choose the representation of float, double, and long double to be the same as the decimal floating types.^[3]

Despite that, the radix has historically been binary (base 2), meaning numbers like 1/2 or 1/4 are exact, but not 1/10, 1/100 or 1/3. With decimal floating point all the same numbers are exact plus numbers like 1/10 and 1/100, but still not e.g. 1/3. No known implementation does opt into the decimal radix for the previously known to be binary types. Since most computers do not even have the hardware for the decimal types, and those few that do (e.g. IBM mainframes since IBM System z10), can use the explicitly decimal types.

The following table describes the specifiers that define various storage attributes including duration – static (default for global), automatic (default for local), or dynamic (allocated).^{[citation needed]}

¹ Allocated and deallocated using the malloc() and free() library functions.

Variables declared within a block by default have automatic storage, as do those explicitly declared with the auto^{[note 2]} or register storage class specifiers. The auto and register specifiers may only be used within functions and function argument declarations;^{[citation needed]} as such, the auto specifier is always redundant. Objects declared outside of all blocks and those explicitly declared with the static storage class specifier have static storage duration. Static variables are initialized to zero by default by the compiler.^{[citation needed]}

Objects with automatic storage are local to the block in which they were declared and are discarded when the block is exited. Additionally, objects declared with the register storage class may be given higher priority by the compiler for access to registers; although the compiler may choose not to actually store any of them in a register. Objects with this storage class may not be used with the address-of (&) unary operator. Objects with static storage persist for the program's entire duration. In this way, the same object can be accessed by a function across multiple calls. Objects with allocated storage duration are created and destroyed explicitly with malloc, free, and related functions.

The extern storage class specifier indicates that the storage for an object has been defined elsewhere. When used inside a block, it indicates that the storage has been defined by a declaration outside of that block. When used outside of all blocks, it indicates that the storage has been defined outside of the compilation unit. The extern storage class specifier is redundant when used on a function declaration. It indicates that the declared function has been defined outside of the compilation unit.

The _Thread_local (thread_local in C++, and in C since C23,^{[citation needed]} and in earlier versions of C if the header <threads.h> is included) storage class specifier, introduced in C11, is used to declare a thread-local variable. It can be combined with static or extern to determine linkage.^{[further explanation needed]}

Note that storage specifiers apply only to functions and objects; other things such as type and enum declarations are private to the compilation unit in which they appear.^{[citation needed]} Types, on the other hand, have qualifiers (see below).

Types can be qualified to indicate special properties of their data. The type qualifier const indicates that a value does not change once it has been initialized. Attempting to modify a const qualified value yields undefined behavior, so some compilers store them in rodata or (for embedded systems) in read-only memory (ROM). The type qualifier volatile indicates to an optimizing compiler that it may not remove apparently redundant reads or writes, as the value may change even if it was not modified by any expression or statement, or multiple writes may be necessary, such as for memory-mapped I/O.

An incomplete type is a structure or union type whose members have not yet been specified, an array type whose dimension has not yet been specified, or the void type (the void type cannot be completed). Such a type may not be instantiated (its size is not known), nor may its members be accessed (they, too, are unknown); however, the derived pointer type may be used (but not dereferenced).

They are often used with pointers, either as forward or external declarations. For instance, code could declare an incomplete type like this:

struct thing *pt;

This declares pt as a pointer to struct thing (as well as the incomplete struct type). As all pointers have the same size (regardless of what they point to), code can use pt as a pointer although it cannot access the fields of struct thing.

An incomplete type can be completed later in the same scope by redeclaring it. For example:

struct thing {
    int num;
};

Incomplete types are used to implement recursive structures; the body of the type declaration may be deferred to later in the translation unit:

typedef struct Bert Bert;
typedef struct Wilma Wilma;

struct Bert {
    Wilma *wilma;
};

struct Wilma {
    Bert *bert;
};

Incomplete types are also used for data hiding. The incomplete type is defined in a header file, and the full definition is hidden in a single body file.

In a variable declaration, the asterisk (*) can be considered to mean "pointer-to". For example, int x defines a variable of type int, and int* px defines a variable px that is a pointer to integer. Some contend that based on the language definition, the * is more closly related to the variable than the type and therefore format the code as int *px or int * px.

A pointer value associates two pieces of information: a memory address and a data type.

When a non-static pointer is declared, it has an unspecified value. Dereferencing it without first assigning it, results in undefined behavior.

The & operator specifies the address of the data object after it. In the following example, ptr is assigned the address of a:

int a = 0;
int *ptr = &a;

An asterisk before a variable name (when not in a declaration or a mathematical expression) dereferences a pointer to allow access to the value it points to. In the following example, the integer variable b is set to the value of integer variable a, which is 10:

int a=10;
int *p;
p = &a;
int b = *p;

Arrays store consecutive elements of the same type. The following code declares an array of 100 elements of type int.

int array[100];

If declared outside of a function (globally), the size must be a constant value. If declared in a function, the array size may be a non-constant expression.

The number of elements is available as sizeof(array)/sizeof(int), but if the value is passed to another function, the number of elements is not available via the formal parameter variable.

The primary facility for accessing array elements is the array subscript operator. For example, a[i] accesses the element at index i of array a. Array indexing begins at 0; making last array index equal to the number of elements minus 1. As the standard does not provide for array indexing bounds checking, specifying an index that is out of range, results in undefined behavior.

Due to arrays and pointers being interchangeable, the address of each elements can be expressed in pointer arithmetic. The following table illustrates both methods for the existing the same array:

Since the expression a[i] is semantically equivalent to *(a+i), which in turn is equivalent to *(i+a), the expression can also be written as i[a], although this form is rarely used.

C99 standardized the variable-length array (VLA) in block scope that produced an array sized by runtime information (not a constant value) but with fixed size until the end of the block.^[1] As of C11, this feature is no longer required to be implemented by the compiler.

int n = ...;
int a[n];
a[3] = 10;

The language supports arrays of multiple dimensions – stored in row-major order which is essentially a one-dimensional array with elements that are arrays. Given that ROWS and COLUMNS are constants, the following declares a two-dimensional array of length ROWS; each element of which is an array of COLUMNS integers.

int array2d[ROWS][COLUMNS];

The following is an example of accessing an integer element:

array2d[4][3]

Reading from left to right, this accesses the 5th row, and the 4th element in that row. The expression array2d[4] is an array, which is then subscripting with [3] to access the fourth integer.

Higher-dimensional arrays can be declared in a similar manner.

A multidimensional array should not be confused with an array of pointers to arrays (also known as an Iliffe vector or sometimes an array of arrays). The former is always rectangular (all subarrays must be the same size), and occupies a contiguous region of memory. The latter is a one-dimensional array of pointers, each of which may point to the first element of a subarray in a different place in memory, and the sub-arrays do not have to be the same size.

Although the language provides types for textual character data, neither the language nor the standard library defines a string type, but the null terminated string is commonly used. A string value is a contiguous series of characters with the end denoted by a zero value. The standard library contains many string handling functions for null-terminated strings, but string manipulation can and often is handled via custom code.

A string literal is code text surrounded by double quotes; for example "Hello world!". A literal compiles to an array of the specified char values with a terminating null terminating character to mark the end of the string.

The language supports string literal concatenation – adjacent string literals are treated as joined at compile time. This allows long strings to be split over multiple lines, and also allows string literals from preprocessor macros to be appended to strings at compile time. For example, the source code:

printf(__FILE__ ": %d: Hello "
       "world\n");

becomes the following after the preprocessor expands __FILE__::

printf("helloworld.c" ": %d: Hello "
       "world\n");

which is equivalent to:

printf("helloworld.c: %d: Hello world\n");

The character literal, called character constant, is single-quoted, e.g. 'A', and has type int. To illustrate the difference between a string literal and a character constant, consider that "A" is two characters, 'A' and '\0', whereas 'A' represents a single character (65 in ASCII).

A character constant cannot be empty (i.e. '' is invalid syntax). Multi-character constants (e.g. 'xy') are valid, although rarely useful — they let one store several characters in an integer (e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a 64-bit one). Since the order in which the characters are packed into an int is not specified (left to the implementation to define), portable use of multi-character constants is difficult.

Nevertheless, in situations limited to a specific platform and the compiler implementation, multicharacter constants do find their use in specifying signatures. One common use case is the OSType, where the combination of Classic Mac OS compilers and its inherent big-endianness means that bytes in the integer appear in the exact order of characters defined in the literal. The definition by popular "implementations" are in fact consistent: in GCC, Clang, and Visual C++, '1234' yields 0x31323334 under ASCII.^[5][6]

Like string literals, character constants can also be modified by prefixes, for example L'A' has type wchar_t and represents the character value of "A" in the wide character encoding.

Control characters cannot be included in a string or character literal directly. Instead they can be encoded via an escape sequence starting with a backslash (\). For example, the backslashes in "This string contains \"double quotes\"." indicate that the inner pair of quotes are intended as an actual part of the string, rather than the default reading as a delimiter (endpoint) of the string.

Escape sequences include:

The use of other backslash escapes is not defined by the standard, although compilers often provide additional escape codes as language extensions. For example, the escape sequence \e for the escape character with ASCII hex value 1B which was not added to the standard due to lacking representation in other character sets (such as EBCDIC). It is available in GCC, clang and tcc.

Note that the standard library function printf() uses %% to represent the literal % character.

Since type char is 1 byte wide, a single char value typically can represent at most 255 distinct character codes, not nearly enough for all the different characters in use worldwide. To provide better support for international characters, the first standard (C89) introduced wide characters (encoded in type wchar_t) and wide character strings, which are written as L"Hello world!"

Wide characters are most commonly either 2 bytes (using a 2-byte encoding such as UTF-16) or 4 bytes (usually UTF-32), but Standard C does not specify the width for wchar_t, leaving the choice to the implementor. Microsoft Windows generally uses UTF-16, thus the above string would be 26 bytes long for a Microsoft compiler; the Unix world prefers UTF-32, thus compilers such as GCC would generate a 52-byte string. A 2-byte wide wchar_t suffers the same limitation as char, in that certain characters (those outside the BMP) cannot be represented in a single wchar_t; but must be represented using surrogate pairs.

The original standard specified only minimal functions for operating with wide character strings; in 1995 the standard was modified to include much more extensive support, comparable to that for char strings. The relevant functions are mostly named after their char equivalents, with the addition of a "w" or the replacement of "str" with "wcs"; they are specified in <wchar.h>, with <wctype.h> containing wide-character classification and mapping functions.

The now generally recommended method^{[note 3]} of supporting international characters is through UTF-8, which is stored in char arrays, and can be written directly in the source code if using a UTF-8 editor, because UTF-8 is a direct ASCII extension.

A common alternative to wchar_t is to use a variable-width encoding, whereby a logical character may extend over multiple positions of the string. Variable-width strings may be encoded into literals verbatim, at the risk of confusing the compiler, or using numerical backslash escapes (e.g. "\xc3\xa9" for "é" in UTF-8). The UTF-8 encoding was specifically designed (under Plan 9) for compatibility with the standard library string functions; supporting features of the encoding include a lack of embedded nulls, no valid interpretations for subsequences, and trivial resynchronisation. Encodings lacking these features are likely to prove incompatible with the standard library functions; encoding-aware string functions are often used in such cases.

A structure is a container consisting of a sequence of named members of heterogeneous types; similar to a record in other languages. The first field starts at the address of the structure and the members are stored in consecutive locations in memory, but the compiler can insert padding between or after members for efficiency or as padding required for proper alignment by the target architecture. The size of a structure includes padding.

A structure is declared with the struct keyword followed by an optional identifier name, which is used to identify the form of the structure. The body follows with field declarations that each consist of a type name, a field name and terminated with a semi-colon.

The following declares a structure named s that contains three members. It also declares an instance named tee:

struct s {
    int   x;
    float y;
    char  *z;
} tee;

Structure members cannot have an incomplete or function type. Thus members cannot be an instance of the structure being declared (because it is incomplete at that point) but a field can be a pointer to the type being declared.

Once declared, a variable can be declared of the structure type. The following declares a new instance of the structure s named r:

struct s r;

Although some prefer to declare a struct variable using the struct keyboard some use typedef to alias the struct type into the main type namespace. The following declares a type as s_type which can then be used like s_type s.

typedef struct {int i;} s_type;

A member is accessed using dot notation. For example, given the declaration of tee from above, the member y can be accessed as tee.y.

A structure is commonly accessed via a pointer. Consider struct s *ptee = &tee that defines a pointer to tee, named ptee. Member y of tee can be accessed by dereferencing ptee and using the result as the left operand as (*ptee).y.^[b] Because this operation is common, the language provides an abbreviated syntax for accessing a member directly from a pointer; using ->. For example, ptee->y.

Assigning a value to a member is like assigning a value to a variable. The only difference is that the lvalue (left side value) of the assignment is the name of the member; per above syntax.

A structure can also be assigned as a whole to another structure of the same type; passed by copy as a function argument or return value. For example, tee.x = 74 assigns the value 74 to the member named x in the structure tee, And, ptee->x = 74 does the same for ptee.

The operations supported for a structure are: initialize, copy, get address and access a field. Of note, the language does not support comparing the value of two structures other than via custom code to compare each field.

The language provides a special type of member known as a bit field, which is an integer with a specified size in bits. A bit field is declared as a member of type (signed/unsigned) int, or _Bool,^{[note 4]} plus a suffix after the member name consisting of a colon and a number of bits. The total number of bits in a single bit field must not exceed the total number of bits of its base type. Contrary to the usual C syntax rules, it is implementation-defined whether a bit field is signed or unsigned if not explicitly specified. Therefore, best practice is to specify signed or unsigned.

Unnamed fields indicate padding and consist of just a colon followed by a number of bits. Specifying a width of zero for an unnamed field is used to force alignment to a new word.^[7] Since all members of a union occupy the same memory, unnamed bit-fields of width zero do nothing in unions, however unnamed bit-fields of non zero width can change the size of the union since they have to fit in it.

Bit fields are limited compared to normal fields in that the address-of (&) and sizeof operators are not supported.

The following declares a structure type named f and an instance of it named g. The first field, flag, is a single bit flag; can physically be only 1 or 0. The second field, num, is a signed 4-bit field; range -7...7 or -8...7. The last field adds 3 bits of padding to round out the structure to 8 bits.

struct f {
    unsigned int  flag : 1;
    signed int    num  : 4;
    signed int         : 3;
} g;

For the most part, a union is like a structure except that fields overlap in memory to allow storing values of different type although not at the same time. The union is like the variant record of other languages. Each field refers to the same location in memory. The size of a union is equal to the size of its largest component type plus any padding.

A union is declared with the union keyword. The following declares a union named u and an instance of it named n:

union u {
    int   x;
    float y;
    char  *z;
} n;

Initializing a variable along with declaring it involves appending an equals sign and then a construct that is compatible with the data type. The following initializes an int:

int x = 12;

Because of the language's grammar, a scalar initializer may be enclosed in any number of curly brace pairs. Most compilers issue a warning if there is more than one such pair. The following are legal although arguably unusual:

int y = { 23 };
int z = { { 34 } };

Structures, unions and arrays can be initialized after a declaration via an initializer list.

Since unmatched elements are set to 0, an empty list sets all elements to 0. For example, the following sets all elements of array a and all fields of s to 0:

int a[10] = {};
struct s s = {};

If an array is declared without an explicit size, the array is an incomplete type. The number of initializers determines the size of the array and completes the type. For example:

int x[] = { 0, 1, 2 };

By default, the items of an initializer list correspond with the elements in the order they are defined. Including too many values yields an error. The following statement initializes an instance of the structure s named pi:

struct s {
    int   x;
    float y;
    char  *z;
};
struct s pi = { 3, 3.1415, "Pi" };

Designated initializers allow members to be initialized by name, in any order, and without explicitly providing preceding values. The following initialization is functionally equivalent to the previous:

struct s pi = { .z = "Pi", .x = 3, .y = 3.1415 };

Using a designator in an initializer moves the initialization "cursor". In the example below, if MAX is greater than 10, there will be some zero-valued elements in the middle of a; if it is less than 10, some of the values provided by the first five initializers will be overridden by the second five. If MAX is less than 5, there will be a compilation error:

int a[MAX] = { 1, 3, 5, 7, 9, [MAX-5] = 8, 6, 4, 2, 0 };

In C89, a union was initialized with a single value applied to its first member. That is, the union u defined above could only have its x member initialized:

union u value = { 3 };

Using a designated initializer, the member to be initialized does not have to be the first member:

union u value = { .y = 3.1415 };

Compound designators can be used to provide explicit initialization when unadorned initializer lists might be misunderstood. In the example below, w is declared as an array of structures, each structure consisting of a member a (an array of 3 int) and a member b (an int). The initializer sets the size of w to 2 and sets the values of the first element of each a:

struct { int a[3], b; } w[] = { [0].a = {1}, [1].a[0] = 2 };

This is equivalent to:

struct { int a[3], b; } w[] =
{
   { { 1, 0, 0 }, 0 },
   { { 2, 0, 0 }, 0 } 
};

It is possible to borrow the initialization methodology to generate compound structure and array literals:

// pointer created from array literal.
int *ptr = (int[]){ 10, 20, 30, 40 };

// pointer to array.
float (*foo)[3] = &(float[]){ 0.5f, 1.f, -0.5f };

struct s pi = (struct s){ 3, 3.1415, "Pi" };

Compound literals are often combined with designated initializers to make the declaration more readable:^[1]

pi = (struct s){ .z = "Pi", .x = 3, .y = 3.1415 };

A pointer to a function can be declared like:

type-name (*function-name)(parameter-list);

The following program code demonstrates the use of a function pointer for selecting between addition and subtraction. Line 5 defines a function pointer variable named operation that supports the same interface as both the add and subtract functions. Based on the conditional (argc), operation is assigned to the address of either add or subtract. On line 7, the function that operation points to is called.

int add(int x, int y) { return x + y; }
int subtract(int x, int y) { return x - y; }
int main(int argc, char* args[])
{
   int (*operation)(int x, int y);
   operation = argc ? add : subtract;
   int result = operation(1, 1);
   return result;
}

A label marks a point in the code to which control can be transferred. A label is an identifier followed by a colon. For example:

if (i == 1) goto END;
// other code
END:

The standard does not define a method to retrieve the address of a label, but GCC extends the language with a unary && operator that returns the address of a label. The address can be stored in a void* variable and may be used later with a goto. This feature can be used to implement a jump table.

For example, the following prints hi repeatedly:

void *ptr = &&J1;
J1: printf("hi");
goto *ptr;

A compound statement, a.k.a. statement block, is a matched pair of curly braces with any number of statements between, like:

{
   {statement}
}

As a compound statement is a type of statement, when statement is used, it could be a single statement (without enclosing braces) or a compound statement (with enclosing braces). A compound statement is required for a function body and for a control structure branch that is not one statement.

A variable declared in a block can be referenced by code in that block (and inner blocks) below the declaration. Access to memory used for a block-declared variable after the block close (i.e. via a pointer) results in undefined behavior.

The if conditional statement is like:

if (expression)
    statement
else
    statement

If the expression is not zero, control passes to the fist statement. Otherwise, control passes to the second statement. If the else part is absent, then when the expression evaluates to zero, the first statement is simply skipped. An else always matches the nearest previous unmatched if. Braces may be used to override this when necessary, or for clarity.

Notably, the second statement can be another if statement. For example:

if (i == 1)
    printf("it's 1");
else if (i == 2)
    printf("it's 2");
else
    printf("it's something else");

The switch transfers control to the case label that has a value matching the integral type expression or otherwise to the default label (if any). Control continues to the statements that follow the case label until a break statement or until the end of the switch statement. The syntax is like:

switch(expression)
{
    case label-name:
        statement
    case label-name:
        statement
    .
    .
    .
    default:
        statement
}

Each case value must be unique within the statement. There may be at most one default label.

Execution continues from one case label to the next if no break statement is encounters. This is known as falling through which is useful in some circumstances, but often is not not desired.

It is possible, although unusual, to locate case labels in the sub-blocks of inner control structures. Examples include Duff's device and Simon Tatham's implementation of coroutines in Putty.^[8]

There are three forms of iteration statement:

while (expression)
    statement

do
    statement
while (expression)

for (init; test; next)
    statement

For the while and do statements, the sub-statement is executed repeatedly so long as the value of the expression is non-zero. For while, the test, including any side effects, occurs before each iteration. For do, the test occurs after each iteration. Thus, a do statement always executes its sub-statement at least once, whereas while might not execute the sub-statement at all.

The logic of for can be described in terms of while in that this:

for (e1; e2; e3)
    s;

is equivalent to:

e1;
while (e2)
{
    s;
cont:
    e3;
}

except for the behavior of a continue; statement (which in the for loop jumps to e3 instead of e2). If e2 is blank, it would have to be replaced with a 1.

Any of the three expressions in the for loop may be omitted. A missing second expression makes the while test always non-zero; describing an infinite loop.

Since C99, the first expression may take the form of a declaration with scope limited to the sub-statement For example:

for (int i = 0; i < limit; ++i) {
    // ...
}

There are four jump statements (transfer control unconditionally): goto, continue, break, and return.

The goto statement passes program control to a labeled statement. It has the following syntax:

goto label-name

A continue statement which is simply the word continue, transfers control to the loop-continuation point of the innermost, enclosing iteration statement. It must be enclosed within an iteration statement. For example:

while (1)
{
    // ...
    continue;
}

do
{
    // ...
    continue;
} while (1);

for (; ; ) {
    // ...
    continue;
}

The break statement which is simply the word break ends a for, while, do, or switch statement. Control passes to the statement following the enclosing control statement.

The return statement transfers control the function caller. When return is followed by an expression, the value is returned to the caller. Encountering the end of the function is equivalent to a return with no expression. In that case, if the function is declared as returning a value and the caller tries to use the returned value, the behavior is undefined.

For a function that returns a value, a definition consists of a return type name, a function name that is unique in the codebase, a list of parameters in parentheses, and a statement block that ends with a return statement. The block can contain a return statement to exit the function before the end of the block. The syntax is like:

type-name function-name(parameter-list)
{
   statement-list
   return value;
}

A function that returns no value is declared with void instead of a type name, like:

void function-name(parameter-list)
{
   statement-list
}

The standard does not include lamba functions, but some translators do.

A parameter-list is a comma-separated list of formal parameter declarations; each item a type name followed by a variable name:

type-name variable-name{, type-name variable-name}

The return type cannot be an array or a function. For exmaple:

int f()[3];    // Error: function returning an array
int (*g())[3]; // OK: function returning a pointer to an array

void h()();    // Error: function returning a function
void (*k())(); // OK: function returning a function pointer

If the function accepts no parameters, the parameter-list may be the keyword void or blank, but these have different implications. Calling a function with arguments when it is declared with void for the parameter-list is invalid syntax. Calling a function with arguments when it is declared with a blank parameter-list is not invalid syntax, but may result in undefined behavior. Using void, is therefore, best practice.

A function can accept a variable number of arguments by including ... at the end of the argument list. A commonly used function with this declaration is the standard library function printf which has prototype:

int printf(const char *, ...);

Consuming variable length arguments can be accomplished via standard library functions declared in <stdarg.h>.

Code can access a function of a library if it is both declared and defined. Often a declaration is provided for a library function via a header file that the consuming code uses via the #include directive. Alternatively, the consuming code can declare the function in its own file. The function definition is associated with the consuming code at link-time. The standard library is generally linked by default whereas other libraries require link-time configuration.

Accessing a user-defined function that is defined in a different file is similar to using a library function. The consuming code declares the function either by including a header file or directly in its file. Linking to the definition in the other file is handled when the object files are linked.

Calling a function that is defined in the same file is relatively simple. The definition or a declaration of it must be above the call.

An argument is passed to a function by value which means that a called function receives a copy of the argument and cannot alter the argument variable. For a function to alter the value of a variable, the caller passes the variable's address (a pointer) which simulates what other languages provide as by reference. The called function can modify the variable by dereferencing the passed address.

In the following code, the address of x is passed by specifing &x in the call. The called function receives the address as y and accesses x as *y.

void incInt(int *y) { (*y)++; }
int main(void)
{
    int x = 7;
    incInt(&x);
    return 0;
}

The following code demonstrates a more advanced use of pointers – passing a pointer to a pointer. An int pointer named a is defined on line 9 and its address is passed to the function on line 10. The function receives a pointer to pointer to int named a_p. It assigns a (as *a_p). After the call, on line 11, the memory allocated and assigned to address a is freed.

#include <stdio.h>
#include <stdlib.h>

void allocate_array(int ** const a_p, const int count) {
    *a_p = malloc(sizeof(int) * count); 
}

int main(void) {
    int *a;
    allocate_array(&a, 42);
    free(a);
    return 0;
}

Function parameters of array type may at first glance appear to be an exception to the pass-by-value rule as demonstrated by the following program that prints 123; not 1:

#include <stdio.h>

void setArray(int array[], int index)
{
    array[index] = 123;
}

int main(void)
{
    int a[1] = {1};
    setArray(a, 0);
    printf("a[0]=%d\n", a[0]);
    return 0;
}

However, there is a different reason for this behavior. An array parameter is treated as a pointer. The following prototype is equivalent to the function prototype above:

void setArray(int *array, int index);

At the same time, rules for the use of arrays in expressions cause the value of a to be treated as a pointer to the first element. Thus, this is still pass-by-value, with the caveat that it is the address of the first element of the array being passed by value; not the contents of the array.

Since C99, the programmer can specify that a function takes an array of a certain size by using the keyword static. In void setArray(int array[static 4], int index) the first parameter must be a pointer to the first element of an array of length at least 4. It is also possible to use qualifiers (const, volatile and restrict) to the pointer type that the array is converted to.

Added in C23 and originating from C++11, C supports attribute specifier sequences.^[9] Attributes can be applied to any symbol that supports them, including functions and variables, and any symbol marked with an attribute will be specifically treated by the compiler as necessary. These can be thought of as similar to Java annotations for providing additional information to the compiler, however they differ in that attributes in C are not metadata that is meant to be accessed using reflection. Furthermore, one cannot create custom attributes in C, unlike in Java where one may define custom annotations in addition to the standard ones. However, C does have implementation/vendor-specific attributes which are non-standard. These typically have a namespace associated with them. For instance, GCC and Clang have attributes under the gnu:: namespace, and all such attributes are of the form [[gnu::*]], though C does not have support for namespacing in the language.

The syntax of using an attribute on a function is like so:

[[nodiscard]]
bool satisfiesProperty(const struct MyStruct* s);

The standard defines the following attributes:

• Blocks (C language extension)
• C data types
• C Sharp syntax
• C standard library
• C++ syntax
• Java syntax
• List of C-family programming languages
• Rust syntax
• Operators in C and C++

General

• The syntax of C in Backus–Naur form
• Programming in C
• The comp.lang.c Frequently Asked Questions Page